# -*- coding: utf-8 -*-
#   单据管理的基类
# @Time    ： 2022/1/5 10:12
# @Auther  ： 徐良
# File     :  billBase.py

from typing import List, Any, Dict, Optional, Union
from PySide6.QtWidgets import QWidget
from mesParts.model.bodyModel import BodyModel
from mesParts.model.headModel import HeadModel
from share.dataFactory import DataFactory
from share.strFunction import get_list_from_str_by_comma
from middleEnum import Alignment
from businessLogic.globalDict.global_domain import domain_dict
from baseClass.tools.tableToList import TableToListDict


class BillBase(QWidget):
    """
    单据处理基类，支持表头表体数据管理
    分离构造与配置
    """

    def __init__(self, parent: Optional[QWidget] = None):
        """
        初始化单据处理类

        Args:
            ms_dict: 主从表配置字典，应包含：
                - 'msFNumber': 模块编码
                - 'msClass': 单据类型， 如，表头表体，单表头，单表体
                - 'msSaveType': 单据保存类型， 如，保存类型(-1-新增，1-维护旧记录)
                - 'FPID': 单据的父ID的值，默认为-1， 实际上就是表头表的FID的值
        """
        super().__init__(parent)
        self.WORK_CLASS_NAME = '表头表体'
        self.ms_dict = None

    # region 基本功能
    def create_factory(self, ms_dict: Optional[Dict] = None, parent: Optional[QWidget] = None):

        self.ms_dict = ms_dict
        if self.ms_dict:
            self.__interface_add_type = 'other'  # 单据增加类型，interface 由界面增加， other 其它方式增加
            self.__body_model: Optional[BodyModel] = None  # 表体数据模型
            self.__head_model: Optional[HeadModel] = None  # 表头数据模型
            self.__m_rob_flag = 0  # 红蓝字单据标志：0-蓝字(默认)，1-红字
            self.__m_rob_qty_name = 'FQty'  # 表体数量字段名，默认FQty

            # 主从表配置相关属性
            self.__m_config_id: int = -1  # 主从表配置ID
            self.__m_number: str = self.ms_dict['msFNumber']  # 主从表编号
            self.__m_class: str = self.ms_dict['msClass']  # 表单类型('11'-有表头表体，'10'-只有表头)
            self.__m_parent_table_id: int = -1  # 父表记录ID(-1表示空记录)
            self.__m_save_type: int = self.ms_dict['msSaveType']  # 保存类型(-1-新增，1-维护旧记录)

            self.__m_local_sqls: str = ''
            self.__m_local_tables: str = ''
            self.__m_local_head: str = ''
            self.__m_description: str = ''
            self.__m_menus_actions: str = ''
            self.__m_bill_table_name: str = ''
            self.__m_date_field_name: str = ''

            # 表结构信息
            self.__m_head_table: str = ''
            self.__m_body_table: str = ''
            self.__m_head_id_name: str = ''
            self.__m_body_pid_name: str = ''
            self.__m_head_sql: str = ''
            self.__m_body_sql: str = ''

            # 隐藏列配置
            self.__m_local_hide_column_list: list = []
            self.__m_head_hide_column_list: list = []
            self.__m_body_hide_column_list: list = []

            # 界面显示配置 表单的列数、行间隔
            self.__m_head_columns: int = 0
            self.__m_head_spacer_height: int = 0
            self.__m_foot_columns: int = 0
            self.__m_foot_spacer_height: int = 0

            self.init_data(ms_dict)

            # 计算可见字段位置
            self.h_position = [idx for idx, visible in enumerate(self.__h_visible_list) if visible == 1]
            self.b_position = [idx for idx, visible in enumerate(self.__b_visible_list) if visible == 1]
            self.create_models()

    def create_models(
            self,
            h_sql: Optional[str] = None,
            b_sql: Optional[str] = None,
            hid: Optional[int] = -1,
            hid_name: Optional[str] = None,
            b_pid_name: Optional[str] = None
    ) -> None:
        """
        创建表头和表体的数据模型

        Args:
            h_sql: 表头SQL查询语句
            b_sql: 表体SQL查询语句
            hid: 表头记录ID
            hid_name: 表头ID字段名
            b_pid_name: 表体父ID字段名
        """
        h_sql = h_sql or self.__m_head_sql
        b_sql = b_sql or self.__m_body_sql
        hid = hid or -1
        b_pid = hid or -1

        hid_name = (hid_name if hid_name is not None
                    else 'FId' if not self.__m_head_id_name
        else self.__m_head_id_name)

        b_pid_name = (b_pid_name if b_pid_name is not None
                      else 'FEntityID' if not self.__m_body_pid_name
        else self.__m_body_pid_name)

        # 只处理两种情况，1、单表头，2、表头表土， 仅有表头在另外框架中处理
        if self.__m_class == '10':  # 只有表头
            self.head_model = HeadModel(
                work=self,
                sql=h_sql,
                fid=hid,
                fid_name=hid_name
            )
            self.body_model = None
            self.head_model.dirty = False

        elif self.__m_class == '11':  # 有表头和表体
            self.head_model = HeadModel(
                work=self,
                sql=h_sql,
                fid=hid,
                fid_name=hid_name
            )

            self.body_model = BodyModel(
                work=self,
                sql=b_sql,
                pid=b_pid,
                pid_name=b_pid_name,
                align=self.b_align_list
            )

            # 初始化脏数据标志
            self.body_model.dirty = False
            self.head_model.dirty = False

    def create_head_model(
            self,
            sql: Optional[str] = None,
            fid: int = -1,
            fid_name: Optional[str] = None
    ) -> None:
        """
        创建表头数据模型

        根据提供的SQL查询、记录ID和ID字段名初始化表头数据模型。
        如果参数未提供，则使用类中存储的默认值。

        Args:
            sql: 用于查询表头数据的SQL语句，如果为None则使用self._head_sql
            fid: 表头记录ID，默认为-1表示新记录
            fid_name: 表头ID字段名，如果为None则使用self._head_id_name

        Returns:
            None: 方法直接修改实例的head_model属性
        """
        sql = sql or self.__m_head_sql
        fid_name = fid_name or self.__m_head_id_name

        self.head_model = HeadModel(
            work=self,
            sql=sql,
            fid=fid,
            fid_name=fid_name
        )

    def get_domain_list(self, domain_name: str) -> Optional[Union[List[str], List[Dict[str, str]]]]:
        """

        :param domain_name:
        :return:
        """
        xu_n = domain_dict.get_or_add(domain_name, lambda key: self._dispatch_domain(key))
        if domain_name[0: 3] != 'str':
            result_list = [item['fname'] for item in xu_n]
        else:
            result_list = xu_n
        return result_list

    def _dispatch_domain(self, domain_name: str) -> List[Any]:
        head_str = domain_name[0: 3]
        if head_str == 'str':
            ret_list = self._get_domain_from_str(domain_name)
        elif head_str == 'sql':
            ret_list = self._get_domain_from_sql(domain_name)
        else:
            return []

        return ret_list

    @staticmethod
    def _get_domain_from_str(domain_name: str) -> List[str]:
        """
        从t_domain中取出字符串，并解析
        :param domain_name:
        :return:
        """
        sql = f"select * from t_domain where FName='{domain_name}'"
        model = DataFactory.get_query_model_by_sql(sql)
        content = model.record(0).value('FContent')
        return content.split(',')

    @staticmethod
    def _get_domain_from_sql(domain_name: str) -> Union[List[str], List[Dict[str,str]]]:
        """
        从t_domain中取出sql字符串，执行
        :param domain_name:
        :return:
        """
        sql = f"select * from t_domain where FName='{domain_name}'"
        model = DataFactory.get_query_model_by_sql(sql)
        sql = model.record(0).value('FContent')
        # 转换为字典列表
        TTD = TableToListDict(sql)
        list_dict = TTD.get_list_dict()

        return list_dict


    def init_data(self, msDict: dict) -> None:
        """
        初始化主从表配置数据

        参数:
            msDict: 主从表配置字典

        功能:
            1. 从数据库加载主表配置信息
            2. 初始化表头和表体字段的各种属性列表
            3. 设置界面显示相关的配置参数
        """
        # 从数据库加载主表配置信息
        sql = f"select * from t_masterslave where fnumber = '{self.__m_number}'"
        model = DataFactory.get_query_model_by_sql(sql)

        # 基础配置信息
        self.__m_local_sqls = model.record(0).value('FLocalSqls')  # 本地SQL语句
        self.__m_local_tables = model.record(0).value('FLocalTables')  # 本地表名
        self.__m_local_head = model.record(0).value('FlocalHead')  # 本地表头配置
        self.__m_description = model.record(0).value('FDescription')  # 描述信息
        self.__m_menus_actions = model.record(0).value('FMenusAndActions')  # 菜单和动作控制
        self.__m_bill_table_name = model.record(0).value('FBillTableName')  # 单据表名 {'editName':'**单','browseName':'**单'}
        self.__m_date_field_name = model.record(0).value('FDateFieldName')  # 日期字段名(用于查询)

        # 表结构信息
        self.__m_head_table = model.record(0).value('FHeadTable')  # 表头表名
        self.__m_body_table = model.record(0).value('FBodyTable')  # 表体表名
        self.__m_head_id_name = model.record(0).value('FHeadIDName')  # 表头ID字段名
        self.__m_body_pid_name = model.record(0).value('FBodyPIDName')  # 表体父ID字段名

        self.__m_head_sql = model.record(0).value('FHsql')  # 表头SQL
        self.__m_body_sql = model.record(0).value('FBsql')  # 表体SQL

        self.__m_config_id = model.record(0).value('Fid')  # 主从表配置ID

        # 隐藏列配置
        self.__m_local_hide_column_list = get_list_from_str_by_comma(
            model.record(0).value('FLocalHideColumns'))  # 本地表隐藏列
        self.__m_head_rob_fields_list = get_list_from_str_by_comma(model.record(0).value('FHeadRobFields'))  # 表头隐藏列
        self.__m_body_rob_field_list = get_list_from_str_by_comma(model.record(0).value('FBodyRobFields'))  # 表体隐藏列

        # 界面显示配置
        self.__m_head_columns = model.record(0).value('FHeadColumns')  # 表头网格页头列数
        self.__m_head_spacer_height = model.record(0).value('FHeadSpacerHeight')  # 表头网格页头间隔
        self.__m_foot_columns = model.record(0).value('FFootColumns')  # 表头网格页脚列数
        self.__m_foot_spacer_height = model.record(0).value('FFootSpacerHeight')  # 表头网格页脚间隔

        # 初始化表头字段属性列表
        self.__init_header_field_lists()

        # 初始化表体字段属性列表
        self.__init_body_field_lists()

        # 获取表信息
        self.__get_hb_table_info()

    def __init_header_field_lists(self) -> None:
        """初始化表头字段的各种属性列表"""
        self.__h_id = -1
        self.__h_key_list: list = []  # 表头字段 key
        self.__h_field_list = []  # 表头字段 字段名
        self.__h_field_name_list = []  # 表头字段中文名
        self.__h_data_type_list = []  # 表头字段数据类型
        self.__h_field_Val_list = []  # 表头字段缺省值
        self.__h_domain_list = []  # 表头domain
        self.__h_widget_list = []  # 表头字段控件类型
        self.__h_edit_list = []  # 表头字段是否可编辑
        self.__h_must_input_list = []  # 表头字段是否必录
        self.__h_align_list = []  # 表头字段对齐方式
        self.__h_row_list = []  # 表头字段行号
        self.__h_column_list = []  # 表头字段列号
        self.__h_row_span_list = []  # 表头字段跨行数
        self.__h_column_span_list = []  # 表头字段跨列数
        self.__h_label_name_list = []  # 表头字段标签名称
        self.__h_top_foot_list = []  # 表头字段头部或脚部
        self.__h_default_val_list = []  # 表头字段缺省值
        self.__h_validator_list = []  # 表头字段校验器
        self.__h_decimal_list = []  # 表头字段小数点位数
        self.__h_place_holder_text_list = []  # 表头字段提示文字
        self.__h_f7_list = []  # 表头字段是否F7帮助
        self.__h_relation_table_list = []  # 表头字段关联表名及sql
        self.__h_relation_field_name_list = []  # 表头字段关联表中文字段
        self.__h_relation_table_description_list = []  # 表头字段关联表界面描述
        self.__h_relation_hide_column_list = []  # 表头字段关联表界面隐藏列
        self.__h_relation_get_ret_list = []  # 表头字段关联表F7面板字段及返回值
        self.__h_relation_fields_list = []  # 表头字段关联表F7面板字段(用于动态拼sql)
        self.__h_visible_list = []  # 表头字段是否可见
        self.__h_Join_sql_list = []  # 表头字段是否参与拼接sql

    def __init_body_field_lists(self) -> None:
        """初始化表体字段的各种属性列表"""
        self.__b_key_list = []  # 表体字段 key
        self.__b_field_list = []  # 表体字段名
        self.__b_field_name_list = []  # 表体字段中文名
        self.__b_domain_list = []  # 表体字段中文名
        self.__b_data_type_list = []  # 表体字段数据类型
        self.__b_widget_list = []  # 表体字段控件类型
        self.__b_edit_list = []  # 表体字段是否可编辑
        self.__b_align_list = []  # 表体字段对齐方式
        self.__b_default_value_list = []  # 表体字段缺省值
        self.__b_validator_list = []  # 表体字段校验器
        self.__b_decimal_list = []  # 表体字段小数点位数
        self.__b_place_holder_text_list = []  # 表体字段提示文字
        self.__b_f7_list = []  # 表体字段是否F7帮助
        self.__b_relation_table_list = []  # 表体字段关联表名及sql
        self.__b_relation_field_name_list = []  # 表体字段关联表中文字段
        self.__b_relation_Table_description_list = []  # 表体字段关联表界面描述
        self.__b_relation_hide_column_list = []  # 表体字段关联表界面隐藏列
        self.__b_relation_get_Ret_list = []  # 表体字段关联表F7面板字段及返回值
        self.__b_relation_fields_list = []  # 表体字段关联表F7面板字段(用于动态拼sql)
        self.__b_visible_list = []  # 表体字段是否可见
        self.__b_must_input_list = []  # 表体字段是否必录项
        self.__b_column_width_list = []  # 表体字段列宽
        self.__b_dict_name_list = []  # 表体帮助字典名称(从0开始)
        self.__b_group_list = []  # 表体字段是否为组别(属性类表)
        self.__b_join_sql_list = []  # 表体字段是否参与拼接sql

    def __get_hb_table_info(self):
        # 获取表头表体相关数据
        # 处理表头
        sql = f"select * from t_msHead where Fentityid={self.__m_config_id} order by Fxh"
        model = DataFactory.get_query_model_by_sql(sql)
        rows = model.rowCount()
        for i in range(0, rows):
            self.__h_id = model.record(i).value('FId')
            self.__h_field_list.append(model.record(i).value('Ffield').lower().strip())
            self.__h_domain_list.append(model.record(i).value('FDomain').strip())
            self.__h_field_name_list.append(model.record(i).value('FfieldName'))
            self.__h_data_type_list.append(model.record(i).value('FDataType'))
            self.__h_widget_list.append(model.record(i).value('FWidget'))
            self.__h_edit_list.append(model.record(i).value('FIsEdit'))
            self.__h_must_input_list.append(model.record(i).value('FMustInput'))
            self.__h_align_list.append(model.record(i).value('FAlignMent'))
            self.__h_row_list.append(model.record(i).value('FRow'))
            self.__h_column_list.append(model.record(i).value('FColumn'))
            self.__h_row_span_list.append(model.record(i).value('FRowSpan'))
            self.__h_column_span_list.append(model.record(i).value('FColumnSpan'))
            self.__h_label_name_list.append(model.record(i).value('FLabelName'))
            self.__h_top_foot_list.append(model.record(i).value('FTopOrFoot'))
            self.__h_default_val_list.append(model.record(i).value('FDefaultVal'))
            self.__h_validator_list.append(model.record(i).value('FValidator'))
            self.__h_decimal_list.append(model.record(i).value('FDecimal'))
            self.__h_place_holder_text_list.append(model.record(i).value('FPlaceHoderText'))
            self.__h_f7_list.append(model.record(i).value('FIsF7'))
            self.__h_relation_table_list.append(model.record(i).value('FRelationTable'))
            self.__h_relation_field_name_list.append(model.record(i).value('FRelationFieldName'))
            self.__h_relation_table_description_list.append(model.record(i).value('FRTableDescription'))
            self.__h_relation_hide_column_list.append(model.record(i).value('FRelationHideColumn'))
            self.__h_relation_get_ret_list.append(model.record(i).value('FRelationGetAndRet'))
            self.__h_relation_fields_list.append(model.record(i).value('FRelationFields'))
            self.__h_visible_list.append(model.record(i).value('FVisible'))
            self.__h_key_list.append(model.record(i).value('FKey'))
            self.__h_Join_sql_list.append(model.record(i).value('FJoinSQl'))

        # 处理表体
        sql = f"select * from t_msbody where Fentityid={self.__m_config_id} order by Fxh"
        model = DataFactory.get_query_model_by_sql(sql)
        rows = model.rowCount()
        for i in range(0, rows):
            self.__b_field_list.append(model.record(i).value('Ffield').lower().strip())
            self.__b_field_name_list.append(model.record(i).value('FfieldName'))
            self.__b_domain_list.append(model.record(i).value('FDomain'))
            self.__b_data_type_list.append(model.record(i).value('FDataType'))
            self.__b_widget_list.append(model.record(i).value('FWidget'))
            self.__b_edit_list.append(model.record(i).value('FIsEdit'))
            self.__b_align_list.append(model.record(i).value('FAlignMent'))
            self.__b_default_value_list.append(model.record(i).value('FDefaultVal'))
            self.__b_validator_list.append(model.record(i).value('FValidator'))
            self.__b_decimal_list.append(model.record(i).value('FDecimal'))
            self.__b_place_holder_text_list.append(model.record(i).value('FPlaceHoderText'))
            self.__b_f7_list.append(model.record(i).value('FIsF7'))
            self.__b_relation_table_list.append(model.record(i).value('FRelationTable'))
            self.__b_relation_field_name_list.append(model.record(i).value('FRelationFieldName'))
            self.__b_relation_Table_description_list.append(model.record(i).value('FRTableDescription'))
            self.__b_relation_hide_column_list.append(model.record(i).value('FRelationHideColumn'))
            self.__b_relation_get_Ret_list.append(model.record(i).value('FRelationGetAndRet'))
            self.__b_relation_fields_list.append(model.record(i).value('FRelationFields'))
            self.__b_visible_list.append(model.record(i).value('FVisible'))
            self.__b_group_list.append(model.record(i).value('FGroup'))
            self.__b_key_list.append(model.record(i).value('FKey'))
            self.__b_must_input_list.append(model.record(i).value('FMustInput'))
            self.__b_column_width_list.append(model.record(i).value('FColumnWidth'))
            self.__b_dict_name_list.append(model.record(i).value('FF7DictName'))
            self.__b_join_sql_list.append(model.record(i).value('FJoinSQl'))

    # endregion


    # region  t_masterslave表 属性和方法
    @property
    def m_parent_table_id(self) -> int:
        """
        单据主从表父表ID
        :return: 父表ID
        :rtype: integer
        """
        return self.__m_parent_table_id

    @m_parent_table_id.setter
    def m_parent_table_id(self, value: int) -> None:
        """
        单据主从表父表ID
        :param value: 要设置的父表ID值
        :type value: integer
        :return: None
        """
        self.__m_parent_table_id = int(value)

    @property
    def m_class(self) -> str:
        """
        单据形式
        :return: 单据形式代码，11=表头表体，10=表头，01=表体
        :rtype: str
        """
        return self.__m_class

    @m_class.setter
    def m_class(self, value: str) -> None:
        """
        设置单据形式
        :param value: 单据形式代码，11=表头表体，10=表头，01=表体
        :type value: str
        """
        self.__m_class = value

    @property
    def m_number(self) -> str:
        """
        主从表t_mastertable的编码
        :rtype: str
        """
        return self.__m_number

    @m_number.setter
    def m_number(self, val: str) -> None:
        """
        主从表t_mastertable的编码
        :param val: 要设置的单据类型值，-1=新单据，1=旧单据
        :type val: int
        :raises ValueError: 如果输入值不是-1或1时抛出异常
        """
        self.__m_number = val

    @property
    def m_save_type(self) -> int:
        """
        单据保存类型
        :return: -1=新单据，1=旧单据
        :rtype: int
        """
        return self.__m_save_type

    @m_save_type.setter
    def m_save_type(self, val: int) -> None:
        """
        设置单据保存类型
        :param val: -1=新单据，1=旧单据
        :type val: int
        :raises ValueError: 如果值不是-1或1时抛出
        """
        if val not in (-1, 1):
            raise ValueError("单据保存类型必须是-1(新单据)或1(旧单据)")
        self.__m_save_type = val

    @property
    def m_rob_flag(self) -> int:
        """
        获取红蓝字标识
        :return: 红蓝字标识代码
        :rtype: int
        """
        return self.__m_rob_flag

    @m_rob_flag.setter
    def m_rob_flag(self, val: int) -> None:
        """
        设置红蓝字标识
        :param val: 红蓝字标识代码
        :type val: int
        """
        self.__m_rob_flag = val

    @property
    def m_rob_qty_name(self) -> str:
        """
        获取红蓝字单据表体涉及数量的字段名
        """
        return self.__m_rob_qty_name

    @m_rob_qty_name.setter
    def m_rob_qty_name(self, val: str) -> None:
        """
        设置红蓝字单据表体涉及数量的字段名
        :param val: 要设置的字段名称（通常是字符串类型）
        :type val: str
        :raises TypeError: 如果输入不是字符串类型时抛出
        """
        if not isinstance(val, str):
            raise TypeError("字段名必须是字符串类型")
        self.__m_rob_qty_name = val

    @property
    def interface_add_type(self) -> str:
        """
        单据增加类型
        :return: interface 由界面增加， other 其它方式增加
        """
        return self.__interface_add_type

    @interface_add_type.setter
    def interface_add_type(self, val):
        """
        单据增加类型
        :return: interface 由界面增加， other 其它增加方式
        """
        self.__interface_add_type = val

    @property
    def m_head_sql(self) -> str:
        """
        获取主表头SQL查询语句（来自t_masterslave表的FHsql字段）

        该SQL用于在主从表关系中获取主表的头部信息数据

        返回:
            str: 主表头数据的SQL查询字符串
        """
        return self.__m_head_sql

    @property
    def m_body_sql(self) -> str:
        """
        获取主表体SQL查询语句（来自t_masterslave表的FBsql字段）

        该SQL用于在主从表关系中获取主表的明细信息数据

        返回:
            str: 主表体数据的SQL查询字符串
        """
        return self.__m_body_sql

    @property
    def m_local_hide_column_list(self) -> List[int]:
        """
        获取本地需要隐藏的列索引列表（来自t_masterslave表的FLocalHideColumns字段）

        这些列将在本地UI显示时隐藏，但实际数据中仍然存在

        返回:
            List[int]: 需要隐藏的列索引列表（整型数字列表）
        """
        return self.__m_local_hide_column_list

    @property
    def m_local_head(self) -> str:
        """
        获取本地列表头配置（来自t_masterslave表的FLocalHead字段）

        该字段配置本地显示时使用的列表头文本

        返回:
            str: 本地化列表头显示文本
        """
        return self.__m_local_head

    @property
    def m_head_table(self) -> str:
        """
        获取主表头表名称（来自t_masterslave表的FHeadTable字段）

        该字段表示主从关系中主表（表头部分）对应的物理表名

        返回:
            str: 主表头对应的数据库表名
        """
        return self.__m_head_table

    @property
    def m_body_table(self) -> str:
        """
        获取主表体表名称（来自t_masterslave表的FBodyTable字段）

        该字段表示主从关系中明细表（表体部分）对应的物理表名

        返回:
            str: 明细表对应的数据库表名
        """
        return self.__m_body_table

    @property
    def m_date_field_name(self) -> str:
        """
        获取日期字段名称（来自t_masterslave表的FBodyTable相关配置）

        该字段表示业务表中用于记录日期的关键字段名

        返回:
            str: 日期类型字段的名称
        """
        return self.__m_date_field_name

    @property
    def m_head_id_name(self) -> str:
        """
        获取主表ID字段名称（来自t_masterslave表的FHeadIDName字段）

        该字段表示主表(头表)中作为主键的字段名称，用于与明细表关联

        返回:
            str: 主表的主键字段名称
        """
        return self.__m_head_id_name

    @property
    def m_body_pid_name(self) -> str:
        """
        获取明细表父ID字段名称（来自t_masterslave表的FBodyPIDName字段）

        该字段表示明细表(体表)中关联主表的外键字段名称

        返回:
            str: 明细表中指向主表的外键字段名称
        """
        return self.__m_body_pid_name

    @property
    def m_local_tables(self) -> str:
        """
        获取本地表名配置（来自t_masterslave表的FLocalTables字段）

        该字段配置本地处理时使用的表名，可能与实际物理表名不同

        返回:
            str: 本地化处理的表名称
        """
        return self.__m_local_tables

    @property
    def m_local_sqls(self) -> str:
        """
        获取本地SQL语句配置（来自t_masterslave表的FLocalSqls字段）

        该字段配置本地处理时使用的特殊SQL查询语句

        返回:
            str: 本地化处理的SQL语句
        """
        return self.__m_local_sqls

    @property
    def m_description(self) -> str:
        """
        获取主从表配置描述信息（来自t_masterslave表的FDescription字段）

        该字段提供关于此主从表配置的说明性文本，用于帮助理解配置用途

        返回:
            str: 配置的详细描述信息
        """
        return self.__m_description

    @property
    def m_menus_actions(self) -> str:
        """
        获取菜单和工具栏动作配置（来自t_masterslave表的FMenusAndActions字段）

        该字段配置TAB页切换时需要保留的菜单项和工具栏命令，
        格式示例：
        {'browseAction':'关闭,过滤', 'editAction':'退回', 'browseMenu':'', 'editMenu':''}

        返回:
            Dict[str, str]: 包含菜单和动作配置的字典，键为动作类型，值为逗号分隔的动作名称列表
        """
        return self.__m_menus_actions

    @property
    def m_bill_table_name(self) -> str:
        """
        获取单据界面标题配置（来自t_masterslave表的FBillTableName字段）

        该字段配置在不同界面模式下显示的单据标题，
        格式示例：
        {'editName':'编辑 订单', 'browseName':'查看 订单'}

        返回:
            Dict[str, str]: 包含不同模式标题的字典，键为模式名称，值为对应标题文本
        """
        return self.__m_bill_table_name

    @property
    def m_head_rob_fields_list(self) -> List[str]:
        """
        获取表头红蓝字字段（来自t_MasterSlave表的FHeadRobFields字段）

        返回:
            List[int]: 需要隐藏的表头列索引列表（整数列表）
        """
        return self.__m_head_rob_fields_list

    @property
    def m_body_rob_field_list(self) -> List[str]:
        """
        获取表体红蓝字字段（来自t_MasterSlave表的FBodyRobFields字段）

        返回:
            List[str]: 需要隐藏的表体列索引列表（整数列表）
        """
        return self.__m_body_rob_field_list

    @property
    def m_head_columns(self) -> int:
        """
        得到页头的列数
        :return:
        """
        return self.__m_head_columns

    @property
    def m_head_spacer_height(self) -> int:
        """
        得到页头的间隔高度
        :return:
        """
        return self.__m_head_spacer_height

    @property
    def m_foot_columns(self) -> int:
        """
        得到页脚的列数
        :return:
        """
        return self.__m_foot_columns

    @property
    def m_foot_spacer_height(self) -> int:
        """
        得到页脚的间隔高度
        :return:
        """
        return self.__m_foot_spacer_height

    # endregion


    # region t_msHead属性和方法
    # 以下是关于配置表表头表t_msHead信息  **********************************
    @property
    def h_id(self) -> int:
        """
        表头id
        :return:
        """
        return self.__h_id

    @h_id.setter
    def h_id(self, var: int) -> None:
        """
        设置表头id
        :param var:
        :return:
        """
        self.__h_id = int(var)

    @property
    def h_key_list(self) -> List[str]:
        """
        获取表头字段键名列表

        该列表包含表头字段对应的键名/字段名，用于数据绑定和访问

        返回:
            List[str]: 表头字段键名字符串列表
        """
        return self.__h_key_list

    @property
    def h_field_list(self) -> List[str]:
        """
        获取表头字段英文名称列表

        该列表包含表头各字段的英文名称/数据库字段名，用于程序内部处理和数据库操作

        示例: ['id', 'name', 'create_time']

        返回:
            List[str]: 表头字段英文名称列表
        """
        return self.__h_field_list

    @property
    def h_domain_list(self) -> List[str]:
        """
        获取表头字段domain字段
        返回:
            List[str]: 表头字段domain列表
        """
        return self.__h_domain_list

    @property
    def h_field_name_list(self) -> List[str]:
        """
        获取表头中文字段显示名称列表

        该列表包含表头各字段在界面显示的中文名称，与英文字段名一一对应

        示例: ['ID', '姓名', '创建时间']

        返回:
            List[str]: 表头字段中文字段名列表
        """
        return self.__h_field_name_list

    @property
    def h_data_type_list(self) -> List[str]:
        """
        获取表头字段数据类型列表

        该列表定义表头各字段的数据类型，可用于数据验证和格式处理
        可能是类型字符串(如'str','int')或Python类型对象(如str, int)

        示例1: ['str', 'int', 'datetime']
        示例2: [str, int, datetime.datetime]

        返回:
            List[Union[str, Type]]: 字段数据类型列表
        """
        return self.__h_data_type_list

    @property
    def h_visible_list(self) -> List[bool]:
        """
        获取表头字段可见性配置列表

        该列表定义表头各字段是否在界面显示，与字段列表一一对应
        True表示可见，False表示隐藏

        示例: [True, False, True] 表示第2个字段隐藏

        返回:
            List[bool]: 表头字段可见性布尔值列表
        """
        return self.__h_visible_list

    @property
    def h_widget_list(self) -> List[str]:
        """
        获取表头字段对应控件名称或对象列表

        该列表包含表头各字段使用的UI控件类型名称(如'QLineEdit')或控件对象

        示例1: ['QLineEdit', 'QComboBox', 'QDateEdit']
        示例2: [QLineEdit对象, QComboBox对象, None]

        返回:
            List[Union[str, Any]]: 控件类型名称或对象列表
        """
        return self.__h_widget_list

    @property
    def h_label_name_list(self) -> List[str]:
        """
        获取表头字段标签名称列表

        该列表包含表头各字段对应的标签显示名称，用于界面展示
        与字段列表一一对应

        示例: ['ID', '姓名', '创建日期']

        返回:
            List[str]: 表头字段标签名称列表
        """
        return self.__h_label_name_list

    @property
    def h_row_list(self) -> List[int]:
        """
        获取表头各字段所在的行号列表

        该列表定义表头各字段在表格布局中的行位置（从0开始计数）
        用于支持多行表头布局的情况

        示例: [0, 0, 1] 表示前两个字段在第1行，第3个字段在第2行

        返回:
            List[int]: 表头字段对应的行号列表
        """
        return self.__h_row_list

    @property
    def h_column_list(self) -> List[int]:
        """
        获取表头各字段所在的列索引列表

        该列表定义表头各字段在表格布局中的列位置（从0开始计数）
        与行号列表配合使用确定字段在表头网格中的位置

        示例: [0, 1, 0] 表示字段布局为：
               [字段1][字段2]
               [字段3]

        返回:
            List[int]: 表头字段对应的列索引列表
        """
        return self.__h_column_list

    @property
    def h_row_span_list(self) -> List[int]:
        """
        获取表头各字段的行跨度配置列表

        该列表定义表头字段在垂直方向占据的行数（默认为1）
        用于实现字段的垂直合并效果

        示例: [1, 2, 1] 表示第2个字段垂直占据2行

        返回:
            List[int]: 表头字段的行跨度数值列表
        """
        return self.__h_row_span_list

    @property
    def h_column_span_list(self) -> List[int]:
        """
        获取表头各字段的列跨度配置列表

        该列表定义表头字段在水平方向占据的列数（默认为1）
        用于实现字段的水平合并效果

        示例: [1, 2, 1] 表示第2个字段水平占据2列

        返回:
            List[int]: 表头字段的列跨度数值列表
        """
        return self.__h_column_span_list

    @property
    def h_edit_list(self) -> List[int]:
        """
        获取表头各字段的可编辑状态列表

        该列表定义表头各字段是否允许用户编辑
        True表示可编辑，False表示只读

        示例: [True, False, True] 表示第2个字段为只读

        返回:
            List[bool]: 表头字段可编辑状态布尔值列表
        """
        return self.__h_edit_list

    @property
    def h_must_input_list(self) -> List[int]:
        """
        获取表头各字段的必填项配置列表

        该列表定义表头各字段是否必须输入
        True表示必填，False表示可选

        示例: [True, False, True] 表示第1和第3个字段必须填写

        返回:
            List[bool]: 表头字段必填状态布尔值列表
        """
        return self.__h_must_input_list

    @property
    def h_place_holder_text_list(self) -> List[int]:
        """
        获取提示字符
        :return:
        """
        return self.__h_place_holder_text_list

    @property
    def h_Join_sql_list(self) -> List[int]:
        """
        获取表头字段是否加入SQL语句管理的配置列表

        该列表定义表头各字段是否应包含在自动生成的SQL语句中
        True表示包含，False表示排除

        示例: [True, False, True] 表示第2个字段不参与SQL生成

        返回:
            List[bool]: 表头字段SQL包含状态布尔值列表
        """
        return self.__h_Join_sql_list

    @property
    def h_default_val_list(self) -> List[Any]:
        """
        获取表头各字段的默认值列表

        该列表包含表头各字段的初始默认值，类型应与字段数据类型匹配
        支持多种类型：字符串、数字、日期等

        示例: ['', 0, None] 表示第1字段默认为空字符串，第2字段默认为0

        返回:
            List[Any]: 表头字段默认值列表
        """
        return self.__h_default_val_list

    @property
    def h_align_list(self) -> List[Alignment]:
        """
        获取表头各字段的对齐方式列表

        该列表定义表头字段内容的显示对齐方式
        常见取值: 'left'(左对齐)/'center'(居中)/'right'(右对齐)

        示例: ['center', 'left', 'right']

        返回:
            List[str]: 表头字段对齐方式列表
        """
        return self.__h_align_list

    @property
    def h_top_foot_list(self) -> List[int]:
        """
        得到控件放置页头或页脚的属性
        :return:
        """
        return self.__h_top_foot_list

    @property
    def h_relation_table_list(self) -> List[str]:
        """
        f7表头字段--关联表名及sql
        :return:
        """
        return self.__h_relation_table_list

    @property
    def h_relation_field_name_list(self) -> List[str]:
        """
        f7表头字段--关联表中文字段
        :return:
        """
        return self.__h_relation_field_name_list

    @property
    def h_relation_table_description_list(self) -> List[str]:
        """
        f7表头字段--关联表界面描述
        :return:
        """
        return self.__h_relation_table_description_list

    @property
    def h_relation_hide_column_lis(self) -> List[str]:
        """
        f7表头字段--关联表界面隐藏列
        :return:
        """
        return self.__h_relation_hide_column_list

    @property
    def h_relation_get_ret_list(self) -> List[str]:
        """
        f7表头字段--关联表F7面板字段及返回值
        :return:
        """
        return self.__h_relation_get_ret_list

    @property
    def h_relation_fields_list(self) -> List[str]:
        """
        f7表头字段--关联表F7面板字段(用于动态拼sql)
        :return:
        """
        return self.__h_relation_fields_list

    # endregion


    # region t_msbody表的属性和方法
    # 配置表表体t_msbody信息 *******************************************
    @property
    def b_key_list(self) -> List[str]:
        """
        获取表体字段键名列表（主键/外键字段）

        该列表包含表体(明细表)中作为关键字段的字段名集合
        通常用于数据关联和唯一标识

        返回:
            List[str]: 表体关键字段名称列表
        """
        return self.__b_key_list

    @property
    def b_field_list(self) -> List[str]:
        """
        获取表体字段英文名称列表

        该列表包含表体各字段的英文名称/数据库字段名
        用于程序内部处理和数据库操作
        返回:
            List[str]: 表体字段英文名称列表
        """
        return self.__b_field_list

    @property
    def b_field_name_list(self) -> List[str]:
        """
        获取表体字段中文字段显示名称列表

        该列表包含表体各字段在界面显示的中文名称
        与英文字段名列表一一对应
        返回:
            List[str]: 表体字段中文字段名列表
        """
        return self.__b_field_name_list


    @property
    def b_domain_list(self) -> List[str]:
        """
        获取表体字段domain列表

        返回:
            List[str]: 表体字段domain列表
        """
        return self.__b_domain_list

    @property
    def b_data_type_list(self) -> List[str]:
        """
        获取表体字段数据类型列表

        该列表定义表体各字段的数据类型，用于数据验证和格式处理
        支持类型字符串(如'str','int')或Python类型对象(如str, int)
        返回:
            List[str]: 表体字段数据类型列表
        """
        return self.__b_data_type_list

    @property
    def b_visible_list(self) -> List[int]:
        """
        获取表体字段可见性配置列表

        该列表控制表体各字段在界面中的显示状态
        True表示字段可见，False表示隐藏
        返回:
            List[int]: 表体字段可见性布尔值列表
        """
        return self.__b_visible_list

    @property
    def b_group_list(self) -> List[Optional[int]]:
        """
        获取表体字段分组配置列表

        该列表定义表体字段所属的逻辑分组(可为None表示无分组)
        相同分组值的字段在界面中可能会被组织在一起

        返回:
            List[str]: 表体字段分组名称列表(可能包含None)
        """
        return self.__b_group_list

    @property
    def b_default_value_list(self) -> List[Any]:
        """
        获取表体字段默认值列表

        该列表包含表体各字段的初始默认值，类型应与字段数据类型匹配
        支持多种类型：字符串、数字、日期、None等

        返回:
            List[Any]: 表体字段默认值列表，元素类型根据字段类型变化
        """
        return self.__b_default_value_list

    @property
    def b_join_sql_list(self) -> List[int]:
        """
        获取表体字段SQL包含配置列表

        该列表控制表体字段是否包含在自动生成的SQL语句中
        True表示包含在SQL中，False表示排除

        返回:
            List[int]: 表体字段SQL包含标志列表
        """
        return self.__b_join_sql_list

    @property
    def b_widget_list(self) -> List[str]:
        """
        获取表体字段控件配置列表

        该列表定义表体各字段使用的UI控件，可以是：
        - 控件类型名称(如'QLineEdit')
        - 控件对象实例

        返回:
            List[str]: 表体字段控件配置列表
        """
        return self.__b_widget_list

    @property
    def b_f7_list(self) -> List[int]:
        """
        获取表体字段F7帮助控件配置列表

        该列表配置各字段是否启用F7帮助功能及帮助参数


        返回:
            List[int]: F7帮助配置列表
        """

        return self.__b_f7_list

    @property
    def b_must_input_list(self) -> List[int]:
        """
        获取表体字段必填项配置列表

        该列表控制表体各字段是否必须输入
        1表示必填字段（会进行非空校验）
        0表示可选字段

        返回:
            List[int]: 表体字段必填状态列表
        """
        return self.__b_must_input_list

    @property
    def b_align_list(self) -> List[Alignment]:
        """
        获取表体字段对齐方式配置列表

        该列表定义字段内容的显示对齐方式，常见值：

        返回:
            List[str]: 表体字段对齐方式列表
        """
        return self.__b_align_list

    @property
    def b_column_width_list(self) -> List[int]:
        """
        获取表体字段列宽度配置列表

        该列表定义表体各列的显示宽度，支持两种格式：
        - 整型数值：固定像素宽度（如100）


        返回:
            List[int]: 表体列宽度配置列表
        """
        return self.__b_column_width_list

    @property
    def b_dict_name_list(self) -> List[int]:
        """
        获取表体字段列索引列表

        该列表定义表体各字段在表格中的列位置索引（从0开始）
        用于控制字段的显示顺序

        返回:
            List[int]: 表体字段列索引列表
        """
        return self.__b_dict_name_list

    @property
    def b_edit_list(self) -> List[bool]:
        """
        获取表体字段可编辑状态列表

        该列表控制表体各字段是否允许编辑
        1表示可编辑，0表示只读

        返回:
            List[bool]: 表体字段可编辑状态列表
        """
        return self.__b_edit_list

    @property
    def b_relation_table_list(self) -> List[str]:
        """
        获取表体F7关联表的FRelationTable字段值的列表
        :return:
        """
        return self.__b_relation_table_list

    @property
    def b_relation_field_name_list(self) -> List[str]:
        """
        获取表体F7关联字段名FRelationFieldName字段值的列表
        :return:
        """
        return self.__b_relation_field_name_list

    @property
    def b_relation_Table_description_list(self) -> List[str]:
        """
        获取表体F7关联字段名FRelationDescription字段值的列表，用于描述帮助界面
        :return:
        """
        return self.__b_relation_Table_description_list

    @property
    def b_relation_hide_column_list(self) -> List[str]:
        """
        获取表体F7关联字段名FRelationHideColumn字段值的列表
        :return:
        """
        return self.__b_relation_hide_column_list

    @property
    def b_relation_get_ret_list(self) -> List[str]:
        """
        获取表体F7关联字段名FRelationGetAndRet字段值的列表
        :return:
        """
        return self.__b_relation_get_Ret_list

    @property
    def b_relation_fields_list(self) -> List[str]:
        """
        获取表体F7关联字段名FRelationFields字段值的列表
        :return:
        """
        return self.__b_relation_fields_list


    @property
    def b_decimal_list(self) -> List[str]:
        """
        获取表体F小数点保留位数列表
        :return:
        """
        return self.__b_decimal_list

    def b_field_name(self, col: int) -> str:
        """
        根据列号获取对应的字段名

        :param col: 列索引（非负整数）
        :return: 字段名字符串，若列号无效（超出范围或为负数）则返回空字符串
        """
        try:
            # 利用列表索引访问的特性，通过异常处理简化边界判断
            return self.b_field_list[col]
        except IndexError:
            # 覆盖索引越界（包括col为负数或超出列表长度）的情况
            return ''


    # endregion


    # region 表头常用信息字典，表体常用信息字典，表头，表头常用的计算方法
    def get_head_field_info(self, num: int) -> Dict[str, Any]:
        """
        获取表头字段完整配置信息

        参数:
            num (int): 字段索引位置（从0开始）

        返回:
            Dict[str, Any]: 包含字段所有配置的字典，结构为：
            {
                'key': 字段键名,
                'field': 字段英文名,
                'dtype': 数据类型,
                'widget': 控件类型,
                'isedit': 是否可编辑,
                'align': 对齐方式,
                'row': 所在行,
                'column': 所在列,
                'rowspan': 行跨度,
                'columnspan': 列跨度,
                'label': 显示标签,
                'validator': 验证器,
                'decimal': 小数位数,
                'placeHoderText': 占位文本,
                'isF7': F7帮助配置,
                'relationTable': 关联表,
                'relationFieldName': 关联字段,
                'rTableDescription': 关联表描述,
                'relationHideColumn': 关联隐藏列,
                'relationGetAndRet': 关联获取返回配置,
                'relationFields': 关联字段列表
            }

        异常:
            IndexError: 当num超出范围时抛出
        """
        if num < 0 or num >= len(self.__h_field_list):
            raise IndexError("Field index out of range")

        return {
            'key': self.__h_key_list[num],
            'field': self.__h_field_list[num],
            'dtype': self.__h_data_type_list[num],
            'widget': self.__h_widget_list[num],
            'isedit': self.__h_edit_list[num],
            'align': self.__h_align_list[num],
            'row': self.__h_row_list[num],
            'column': self.__h_column_list[num],
            'rowspan': self.__h_row_span_list[num],
            'columnspan': self.__h_column_span_list[num],
            'label': self.__h_label_name_list[num],
            'validator': self.__h_validator_list[num],
            'decimal': self.__h_decimal_list[num],
            'placeHolderText': self.__h_place_holder_text_list[num],
            'isF7': self.__h_f7_list[num],
            'relationTable': self.__h_relation_table_list[num],
            'relationFieldName': self.__h_relation_field_name_list[num],
            'rTableDescription': self.__h_relation_table_description_list[num],
            'relationHideColumn': self.__h_relation_hide_column_list[num],
            'relationGetAndRet': self.__h_relation_get_ret_list[num],
            'relationFields': self.__h_relation_fields_list[num]
        }

    def get_body_field_info(self, num: int) -> Dict[str, Any]:
        """
        获取表体字段完整配置信息

        参数:
            num (int): 字段索引位置（从0开始）

        返回:
            Dict[str, Any]: 包含字段所有配置的字典，结构为：
            {
                'key': 字段键名,
                'field': 字段英文名,
                'dtype': 数据类型,
                'widget': 控件类型,
                'isedit': 是否可编辑,
                'align': 对齐方式,
                'width': 列宽度,
                'validator': 验证器,
                'column': 列位置,
                'decimal': 小数位数,
                'placeHoderText': 占位文本,
                'isF7': F7帮助配置,
                'relationTable': 关联表,
                'relationFieldName': 关联字段,
                'rTableDescription': 关联表描述,
                'relationHideColumn': 关联隐藏列,
                'relationGetAndRet': 关联获取返回配置,
                'relationFields': 关联字段列表
            }

        异常:
            IndexError: 当num超出范围时抛出
        """
        if num < 0 or num >= len(self.__b_field_list):
            raise IndexError("Field index out of range")

        return {
            'key': self.__b_key_list[num],
            'field': self.__b_field_list[num],
            'domain': self.__b_domain_list[num],
            'dtype': self.__b_data_type_list[num],
            'widget': self.__b_widget_list[num],
            'isedit': self.__b_edit_list[num],
            'align': self.__b_align_list[num],
            'width': self.__b_column_width_list[num],
            'validator': self.__b_validator_list[num],
            'dictName': self.__b_dict_name_list[num],
            'decimal': self.__b_decimal_list[num],
            'placeHolderText': self.__b_place_holder_text_list[num],
            'isF7': self.__b_f7_list[num],
            'relationTable': self.__b_relation_table_list[num],
            'relationFieldName': self.__b_relation_field_name_list[num],
            'rTableDescription': self.__b_relation_Table_description_list[num],
            'relationHideColumn': self.__b_relation_hide_column_list[num],
            'relationGetAndRet': self.__b_relation_get_Ret_list[num],
            'relationFields': self.__b_relation_fields_list[num]
        }

    def get_h_field_column(self, field_name: str) -> int:
        """
        获取表头字段在 h_field_list 中的索引位置。

        :param field_name: 要查找的字段名（不区分大小写）。
        :return: 字段在列表中的索引，如果不存在则返回 -1。
        """
        try:
            return self.h_field_list.index(field_name.lower())
        except ValueError:
            return -1

    def get_b_field_column(self, field_name: str) -> int:
        """
        取表体字段在 b_field_list 中的索引位置。
        :param field_name: 要查找的字段名（不区分大小写）。
        :return: 字段在列表中的索引，如果不存在则返回 -1。
        """
        try:
            return self.b_field_list.index(field_name.lower())
        except ValueError:
            return -1

    def get_body_is_edit(self, number: int) -> int:
        """
        返回表体指定列是否可编辑
        :param number:
        :return:
        """
        if number >= len(self.b_edit_list):
            return 0
        else:
            return self.b_edit_list[number]

    def get_b_relation_table_list(self, number: int) -> str:
        """
        返回表体F7关联表表名字符串
        :param number:
        :return:
        """
        if number >= len(self.b_relation_table_list):
            return ''
        else:
            return self.b_relation_table_list[number]

    def get_b_relation_get_and_ret_list(self, number: int) -> str:
        """
        返回表体F7关联表取数、数据类型、返回值字符串
        :param number:
        :return:
        """
        if number >= len(self.b_relation_get_ret_list):
            return ''
        else:
            return self.b_relation_get_ret_list[number]

    def get_h_column_by_field_name(self, field_Name: str) -> int:
        """
        根据表头字段名称获取对应的列索引

        参数:
            field_Name (str): 要查找的表头字段名称（不区分大小写）

        返回:
            int: 字段对应的列索引（从0开始），未找到返回-1

        示例:
            1 >>> get_h_column_by_field_name('fid')
            2  # 返回字段所在的列号
        """
        ret = -1
        field_Name = field_Name.lower()
        for i, field in enumerate(self.__h_field_list):
            if field_Name.lower() == field.lower():
                ret = i
                break
        return ret

    def get_b_column_by_field_name(self, field_Name: str) -> int:
        """
        根据表体字段名称获取对应的列索引

        参数:
            field_Name (str): 要查找的表头字段名称（不区分大小写）

        返回:
            int: 字段对应的列索引（从0开始），未找到返回-1
        """
        ret = -1
        for i, field in enumerate(self.__b_field_list):
            if field_Name.lower() == field.lower():
                ret = i
                break
        return ret

    def get_f7_simple_form_dict(self, field_name: str) -> Dict[str, Any]:
        """
        获取表头简单表帮助文件字典
        :return:
        """
        col = self.get_h_field_column(field_name)
        simple_dict = {
            'tableSql': self.h_relation_table_list[col],
            'field_str': self.h_relation_fields_list[col],
            'field_name_str': self.h_relation_field_name_list[col],
            'column_hide_str': self.h_relation_hide_column_lis[col],
            'get_ret_str': self.h_relation_get_ret_list[col],
            'description': self.h_relation_table_description_list[col]
        }
        return simple_dict

    def get_f7_simple_body_dict(self, num: str) -> Dict[str, Any]:
        """
        根据列号，获取该字典的表体的简单模式的帮助文件字典
        :param num:
        :return:
        """
        pass


    # endregion
